package cn.lcsjsxy.yxc.renerics;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义泛型类
 * @param <T>这里的T可以随意写为任意标识，常见的有T、E等形式的参数表示泛型
 *           泛型在定义的时候不具体，使用的时候才变得具体
 *           在使用的时候确定泛型的具体数据类型。即在创建对象的时候确定泛型
 */
public class Order<T> {
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型。orderT这个成员变量的类型为T，T的类型由外部指定
    T orderT;

    public Order(){
        //编译不通过
//        T[] arr=new T[10];
        //编译通过
        T[] arr=(T[])new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){
        this.orderName=orderName;
        this.orderId=orderId;
        this.orderT=orderT;
    }

    //如下三个方法都不是泛型方法
    //泛型方法getT的返回值类型为T，T的类型由外部指定
    public T getOrderT(){
        return orderT;
    }

    //泛型构造方法形参t的类型也为T，T的类型由外部指定
    public void setOrderT(T orderT){
        this.orderT=orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }

    //静态方法中不能使用类的泛型
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }
    public void show(){
        //编译不通过
//        try {
//
//        }catch (T t){
//
//        }
    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
    //换句话说，泛型方法所属的类是不是泛型类都没有关系
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list=new ArrayList<>();
        for (E e:arr){
            list.add(e);
        }
        return list;
    }
}
